docs(gate): contradictsWrapperResolution's docblock still described the flat bare-name index #13474 replaced - #13846

Fixes #13787

Prose only. contradictsWrapperResolution's predicate is byte-identical to origin/main — 1128 characters, sha256 dccdd2b341d10650… on both sides — and the whole diff is comment lines: 0 non-comment lines added, 0 removed, in 3 hunks that all sit inside that one docblock. The fence #13474 put on the predicate is intact; this card is its docblock, and nothing else.

The corrected clause — before / after

The card is one sentence, and it wraps across two lines, which is why a single-string grep for it returns zero. Before (the only clause in the file that asserted the flat index in the present tense):

 * `contradictsDriverReadShape` asks it of `IDataDriver`. The wrapper hop in
 * `isReadCall` asked nothing at all. `functionBodies` is a flat, file-scoped
 * index keyed by BARE NAME, so any call whose `calleeName` happens to equal a
 * function declared in the same file was followed into that function's body —
 * whatever it was called ON, and whatever it was passed.

After:

 * `contradictsDriverReadShape` asks it of `IDataDriver`. The wrapper hop in
 * `isReadCall` asked nothing at all. `functionBodies` WAS a flat, file-scoped
 * index keyed by BARE NAME, so any call whose `calleeName` happened to equal a
 * function declared in the same file was followed into that function's body —
 * whatever it was called ON, and whatever it was passed. (That index is no
 * longer flat: #13474 made it scope-aware. It did not close THIS question —
 * see the last block of this docblock.)

The paragraph is kept whole. It narrates the historical defect that motivates the predicate, and asked nothing at all / was followed were already past tense on purpose; only the functionBodies clause was wrongly in the present. Two words move (is to WAS, happens to happened) plus a three-line forward pointer. Flattening the whole paragraph to a description of today's index would have deleted the motivation.

The second hunk adds a closing block to the same docblock, next to the existing zero-cost statement, so the reader who lands on the predicate is told what #13474 did and why this predicate survives it:

 * WHY #13474 DID NOT SUBSUME THIS, stated here because the paragraph at the
 * top narrates an index shape the file no longer has. `indexFunctionBodies`
 * now resolves a name through the CALL SITE's lexical scope chain, which
 * settles a collision between same-named BODIES — a different collision from
 * the one asked about here, which is across RECEIVERS. Its ONE DECLARATION
 * ⇒ UNCHANGED rule keeps it that way on purpose: a name with exactly one body
 * in the file is answered from any call site, so a unique name reached on a
 * compound receiver is admitted there and refused only here.
 * `indexFunctionBodies`' own docblock records the same from its side, and this
 * is the near half of that pair. Re-measured on this tree after the resolver
 * changed, with this predicate ablated: the two #12358 cases in the self-test
 * report 1 seam each instead of 0, and `--list` over the scan root is
 * byte-identical either way — the zero-seam cost stated just above, still
 * zero.

That pointer is deliberate and it is the pair's near half: indexFunctionBodies' docblock already points at this predicate from ~900 lines away, and now this one points back.

Is the predicate's motivation still sound after #13474? — measured, and yes

#13784's docblock claims the predicate stays load-bearing (a unique name reached on a compound receiver is admitted by the one-declaration rule and refused by that predicate). Verified on this tree by ablation rather than by reading: return false; injected as the first statement of contradictsWrapperResolution, mutation confirmed on disk before the run (marker count 0 to 1, 335171 to 335207 bytes, git diff --stat one insertion), restored afterwards with git checkout HEAD -- ... and the restore proved by hash (d0dc23ff… before and after) plus an empty git diff HEAD. No build step exists between edit and run — the gate is an .mjs executed from source, not from a dist/.

The two failures are exactly the two #12358 fixtures, one per clause:

✗ passes: #12358 — a compound receiver does not resolve to the same-file method it collides with: expected violation=false seams=0, got violation=false count=0 seams=1
✗ passes: #12358 — a call that cannot satisfy the resolved declaration is not that declaration: expected violation=false seams=0, got violation=false count=0 seams=1

Both fixtures declare delete exactly once, so indexFunctionBodies' one-declaration rule answers the name from any call site and hands the hop straight to this predicate. The scope-aware resolver does not and cannot refuse them — it settles same-name collisions, and there is no collision here. ⇒ the motivation is unchanged in force, narrower in wording: the docblock should no longer say the index is flat, but the reason the predicate exists is untouched, and the file's zero-seam cost figure for it is still zero after the resolver changed.

Census — every bare name / flat index mention in the file, classified

Censused by mechanism (functionBodies, BARE NAME, bare name, flat, LAST-WINS, scope-aware, 13474 as separate terms), never as one contiguous string.

Nothing was changed on grounds of resemblance: 1529–1530 is the only present-tense assertion of the replaced shape.

Verification

Every gate run explicitly, exit code captured before any pipe. Final commit for all of it: de44eb1b9.

The family was re-derived from the real diff with node scripts/pm/dispatch-gates.mjs --repo objectstack-ai/objectstack (no paths passed), which also surfaced the two convention-triggered obligations above.

Why there is no changeset

The dispatch order asked for one. This diff publishes nothing: it is comment lines in scripts/check-durability-degradation-log-level.mjs, a repo-root gate script that belongs to no published package, so a changeset would have to name a package and fabricate a CHANGELOG entry for a comment. An empty-frontmatter changeset is not the alternative — scripts/check-empty-changeset.mjs rejects newly added ones outright, and its header records why. Precedent on this exact file is uniform: of the last 12 commits touching it, the 10 that were script-only carried zero changeset files, #13474's own PR (6207c9ecc) among them. skip-changeset is applied to this PR instead, and read back after applying.

Generated by Claude Code